Seafile Professional Server – mit Docker Compose und Traefik installieren

Seafile Professional Edition ist eine leistungsstarke Sync-&-Share-Lösung, die sich speziell für den Einsatz in Unternehmen und komplexen IT-Umgebungen eignet. Im Vergleich zur Community Edition bietet sie erweiterte Funktionen wie granulare Zugriffssteuerung, automatisiertes File Locking für Office-Dokumente und Integrationen mit Microsoft Office Online oder Collabora, die parallele Teamarbeit an Dateien ohne Versionskonflikte ermöglichen. Seafile Professional kann mit bis zu 3 Benutzern kostenlos genutzt werden.

1. Grundvoraussetzung

• Docker & Docker Compose v2 (Debian / Ubuntu)
• Traefik ab v3.6 mit CrowdSec installieren und konfigurieren

2. Ordner anlegen

Zuerst legen wir uns passende Ordner-Strukturen an.

mkdir -p /opt/containers/seafile-pro/seafile-elasticsearch/data

Nun passen wir noch eine Berechtigung an, damit Elasticsearch später funktioniert (Dank an @eltonit)

chmod 777 -R /opt/containers/seafile-pro/seafile-elasticsearch/data

3. Docker Compose anlegen

Nun legen wir die eigentliche Docker Datei an.

nano /opt/containers/seafile-pro/docker-compose.yml

Inhalt

services:
  db:
    image: ${SEAFILE_DB_IMAGE:-mariadb:10.11}
    container_name: seafile-mysql
    restart: unless-stopped
    env_file:
      - .env
    environment:
      - MYSQL_ROOT_PASSWORD=${INIT_SEAFILE_MYSQL_ROOT_PASSWORD:-}
      - MYSQL_LOG_CONSOLE=true
      - MARIADB_AUTO_UPGRADE=1
    volumes:
      - "${SEAFILE_MYSQL_VOLUME:-/opt/seafile-mysql/db}:/var/lib/mysql"
    networks:
      - seafile-net
    healthcheck:
      test:
        [
          "CMD",
          "/usr/local/bin/healthcheck.sh",
          "--connect",
          "--mariadbupgrade",
          "--innodb_initialized",
        ]
      interval: 20s
      start_period: 30s
      timeout: 5s
      retries: 10

  redis:
    image: ${SEAFILE_REDIS_IMAGE:-redis}
    container_name: seafile-redis
    restart: unless-stopped
    env_file:
      - .env
    command:
      - /bin/sh
      - -c
      - redis-server --requirepass "$$REDIS_PASSWORD"
    environment:
      - REDIS_PASSWORD=${REDIS_PASSWORD:-}
    networks:
      - seafile-net

  seafile:
    image: ${SEAFILE_IMAGE:-seafileltd/seafile-pro-mc:13.0-latest}
    container_name: seafile
    restart: unless-stopped
    env_file:
      - .env
    volumes:
      - ${SEAFILE_VOLUME:-/opt/seafile-data}:/shared
    environment:
      - INIT_SEAFILE_MYSQL_ROOT_PASSWORD=${INIT_SEAFILE_MYSQL_ROOT_PASSWORD:-}
      - SEAFILE_MYSQL_DB_HOST=${SEAFILE_MYSQL_DB_HOST:-db}
      - SEAFILE_MYSQL_DB_PORT=${SEAFILE_MYSQL_DB_PORT:-3306}
      - SEAFILE_MYSQL_DB_USER=${SEAFILE_MYSQL_DB_USER:-seafile}
      - SEAFILE_MYSQL_DB_PASSWORD=${SEAFILE_MYSQL_DB_PASSWORD:?Variable is not set or empty}
      - SEAFILE_MYSQL_DB_CCNET_DB_NAME=${SEAFILE_MYSQL_DB_CCNET_DB_NAME:-ccnet_db}
      - SEAFILE_MYSQL_DB_SEAFILE_DB_NAME=${SEAFILE_MYSQL_DB_SEAFILE_DB_NAME:-seafile_db}
      - SEAFILE_MYSQL_DB_SEAHUB_DB_NAME=${SEAFILE_MYSQL_DB_SEAHUB_DB_NAME:-seahub_db}
      - TIME_ZONE=${TIME_ZONE:-Etc/UTC}
      - INIT_SEAFILE_ADMIN_EMAIL=${INIT_SEAFILE_ADMIN_EMAIL:-me@example.com}
      - INIT_SEAFILE_ADMIN_PASSWORD=${INIT_SEAFILE_ADMIN_PASSWORD:-asecret}
      - SEAFILE_SERVER_HOSTNAME=${SEAFILE_SERVER_HOSTNAME:?Variable is not set or empty}
      - SEAFILE_SERVER_PROTOCOL=${SEAFILE_SERVER_PROTOCOL:-http}
      - SITE_ROOT=${SITE_ROOT:-/}
      - NON_ROOT=${NON_ROOT:-false}
      - JWT_PRIVATE_KEY=${JWT_PRIVATE_KEY:?Variable is not set or empty}
      - SEAFILE_LOG_TO_STDOUT=${SEAFILE_LOG_TO_STDOUT:-false}
      - ENABLE_GO_FILESERVER=${ENABLE_GO_FILESERVER:-true}
      - ENABLE_SEADOC=${ENABLE_SEADOC:-true}
      - SEADOC_SERVER_URL=${SEAFILE_SERVER_PROTOCOL:-http}://${SEAFILE_SERVER_HOSTNAME:?Variable is not set or empty}/sdoc-server
      - CACHE_PROVIDER=${CACHE_PROVIDER:-redis}
      - REDIS_HOST=${REDIS_HOST:-redis}
      - REDIS_PORT=${REDIS_PORT:-6379}
      - REDIS_PASSWORD=${REDIS_PASSWORD:-}
      - SEAF_SERVER_STORAGE_TYPE=${SEAF_SERVER_STORAGE_TYPE:-}
      - S3_COMMIT_BUCKET=${S3_COMMIT_BUCKET:-}
      - S3_FS_BUCKET=${S3_FS_BUCKET:-}
      - S3_BLOCK_BUCKET=${S3_BLOCK_BUCKET:-}
      - S3_KEY_ID=${S3_KEY_ID:-}
      - S3_SECRET_KEY=${S3_SECRET_KEY:-}
      - S3_USE_V4_SIGNATURE=${S3_USE_V4_SIGNATURE:-true}
      - S3_AWS_REGION=${S3_AWS_REGION:-us-east-1}
      - S3_HOST=${S3_HOST:-}
      - S3_USE_HTTPS=${S3_USE_HTTPS:-true}
      - S3_PATH_STYLE_REQUEST=${S3_PATH_STYLE_REQUEST:-false}
      - S3_SSE_C_KEY=${S3_SSE_C_KEY:-}
      - ENABLE_NOTIFICATION_SERVER=${ENABLE_NOTIFICATION_SERVER:-false}
      - INNER_NOTIFICATION_SERVER_URL=${INNER_NOTIFICATION_SERVER_URL:-http://notification-server:8083}
      - NOTIFICATION_SERVER_URL=${NOTIFICATION_SERVER_URL:-${SEAFILE_SERVER_PROTOCOL:-http}://${SEAFILE_SERVER_HOSTNAME:?Variable is not set or empty}/notification}
      - ENABLE_SEAFILE_AI=${ENABLE_SEAFILE_AI:-false}
      - SEAFILE_AI_SERVER_URL=${SEAFILE_AI_SERVER_URL:-http://seafile-ai:8888}
      - SEAFILE_AI_SECRET_KEY=${JWT_PRIVATE_KEY:?Variable is not set or empty}
      - MD_FILE_COUNT_LIMIT=${MD_FILE_COUNT_LIMIT:-100000}
    labels:
      - "traefik.enable=true"
      - "traefik.http.routers.seafile.rule=Host(`${SEAFILE_SERVER_HOSTNAME}`)"
      - "traefik.http.routers.seafile.entrypoints=websecure"
      - "traefik.http.routers.seafile.tls=true"
      - "traefik.http.routers.seafile.tls.certresolver=http_resolver"
      - "traefik.http.services.seafile.loadbalancer.server.port=80"
      - "traefik.docker.network=proxy"
    healthcheck:
      test: ["CMD-SHELL", "curl -f http://localhost:80 || exit 1"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 10s
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
    networks:
      - seafile-net
      - proxy

  elasticsearch:
    image: ${SEAFILE_ELASTICSEARCH_IMAGE:-elasticsearch:8.15.0}
    container_name: seafile-elasticsearch
    restart: unless-stopped
    env_file:
      - .env
    environment:
      - discovery.type=single-node
      - bootstrap.memory_lock=true
      - "ES_JAVA_OPTS=-Xms2g -Xmx2g"
      - "xpack.security.enabled=false"
    ulimits:
      memlock:
        soft: -1
        hard: -1
    mem_limit: 4g
    volumes:
      - "${SEAFILE_ELASTICSEARCH_VOLUME:-/opt/seafile-elasticsearch/data}:/usr/share/elasticsearch/data"
    networks:
      - seafile-net

  seadoc:
    image: ${SEADOC_IMAGE:-seafileltd/sdoc-server:2.0-latest}
    container_name: seadoc
    restart: unless-stopped
    env_file:
      - .env
    volumes:
      - ${SEADOC_VOLUME:-/opt/seadoc-data/}:/shared
    environment:
      - DB_HOST=${SEAFILE_MYSQL_DB_HOST:-db}
      - DB_PORT=${SEAFILE_MYSQL_DB_PORT:-3306}
      - DB_USER=${SEAFILE_MYSQL_DB_USER:-seafile}
      - DB_PASSWORD=${SEAFILE_MYSQL_DB_PASSWORD:?Variable is not set or empty}
      - DB_NAME=${SEADOC_MYSQL_DB_NAME:-${SEAFILE_MYSQL_DB_SEAHUB_DB_NAME:-seahub_db}}
      - TIME_ZONE=${TIME_ZONE:-Etc/UTC}
      - JWT_PRIVATE_KEY=${JWT_PRIVATE_KEY:?Variable is not set or empty}
      - NON_ROOT=${NON_ROOT:-false}
      - SEAHUB_SERVICE_URL=${SEAFILE_SERVICE_URL:-http://seafile}
    labels:
      - "traefik.enable=true"

      # --- Router 1: Web Zugriff (/sdoc-server/) ---
      - "traefik.http.routers.seadoc-web.rule=Host(`${SEAFILE_SERVER_HOSTNAME}`) && PathPrefix(`/sdoc-server`)"
      - "traefik.http.routers.seadoc-web.entrypoints=websecure"
      - "traefik.http.routers.seadoc-web.tls.certresolver=http_resolver"
      - "traefik.http.routers.seadoc-web.service=seadoc"
      - "traefik.http.middlewares.seadoc-strip.stripprefix.prefixes=/sdoc-server"
      - "traefik.http.routers.seadoc-web.middlewares=seadoc-strip"

      # --- Router 2: WebSocket / Socket.io (/socket.io) ---
      - "traefik.http.routers.seadoc-socket.rule=Host(`${SEAFILE_SERVER_HOSTNAME}`) && PathPrefix(`/socket.io`)"
      - "traefik.http.routers.seadoc-socket.entrypoints=websecure"
      - "traefik.http.routers.seadoc-socket.tls.certresolver=http_resolver"
      - "traefik.http.routers.seadoc-socket.service=seadoc"

      - "traefik.http.services.seadoc.loadbalancer.server.port=80"
      - "traefik.docker.network=proxy"
    depends_on:
      db:
        condition: service_healthy
    networks:
      - seafile-net
      - proxy
networks:
  seafile-net:
    name: seafile-net
  proxy:
    external: trueCode-Sprache: PHP (php)

4. .env Datei erstellen

Nur erstellen wir noch eine Datei, welche die eigentliche Konfiguration beinhaltet:

nano /opt/containers/seafile-pro/.env

Inhalt:

#################################
# Docker compose configurations #
#################################
## Images
SEAFILE_IMAGE=seafileltd/seafile-pro-mc:13.0-latest
SEAFILE_DB_IMAGE=mariadb:10.11
SEAFILE_REDIS_IMAGE=redis
SEAFILE_ELASTICSEARCH_IMAGE=elasticsearch:8.15.0
SEADOC_IMAGE=seafileltd/sdoc-server:2.0-latest
NOTIFICATION_SERVER_IMAGE=seafileltd/notification-server:13.0-latest
#SEASEARCH_IMAGE=seafileltd/seasearch-nomkl:1.0-latest # Apple's Chip for SeaSearch
SEASEARCH_IMAGE=seafileltd/seasearch:1.0-latest
MD_IMAGE=seafileltd/seafile-md-server:13.0-latest

## Storage

### Storage type
SEAF_SERVER_STORAGE_TYPE=disk # disk, s3, multiple
MD_STORAGE_TYPE=$SEAF_SERVER_STORAGE_TYPE # disk, s3
SS_STORAGE_TYPE=$SEAF_SERVER_STORAGE_TYPE # disk, s3

### Local storage path
BASIC_STORAGE_PATH=/opt/containers/seafile-pro
SEAFILE_VOLUME=$BASIC_STORAGE_PATH/seafile-data
SEAFILE_MYSQL_VOLUME=$BASIC_STORAGE_PATH/seafile-mysql/db
SEAFILE_ELASTICSEARCH_VOLUME=$BASIC_STORAGE_PATH/seafile-elasticsearch/data
SS_DATA_PATH=$BASIC_STORAGE_PATH/seasearch-data
SEADOC_VOLUME=$BASIC_STORAGE_PATH/seadoc-data

### Storage configurations for S3 (only valid in XXX_STORAGE_TYPE=s3)
S3_COMMIT_BUCKET=<your commit bucket name>
S3_FS_BUCKET=<your fs bucket name>
S3_BLOCK_BUCKET=<your block bucket name>
S3_SS_BUCKET=<your seasearch bucket name> # for seasearch
S3_MD_BUCKET=<your metadata bucket name> # for metadata-server
S3_KEY_ID=<your-key-id>
S3_SECRET_KEY=<your-secret-key>
S3_USE_V4_SIGNATURE=true
S3_PATH_STYLE_REQUEST=false
S3_AWS_REGION=us-east-1
S3_HOST=
S3_USE_HTTPS=true
S3_SSE_C_KEY=

#################################
#      Startup parameters       #
#################################
SEAFILE_SERVER_HOSTNAME=seafile.euredomain.de
SEAFILE_SERVER_PROTOCOL=https
TIME_ZONE=Europe/Berlin
JWT_PRIVATE_KEY=

#####################################
# Third-party service configuration #
#####################################

## Database
SEAFILE_MYSQL_DB_HOST=db
SEAFILE_MYSQL_DB_USER=seafile
SEAFILE_MYSQL_DB_PASSWORD=password
SEAFILE_MYSQL_DB_CCNET_DB_NAME=ccnet_db
SEAFILE_MYSQL_DB_SEAFILE_DB_NAME=seafile_db
SEAFILE_MYSQL_DB_SEAHUB_DB_NAME=seahub_db

## Cache
CACHE_PROVIDER=redis

### Redis
REDIS_HOST=redis
REDIS_PORT=6379
REDIS_PASSWORD=


######################################
#        Initial variables           #
# (Only valid in first-time startup) #
######################################

## Database root password, Used to create Seafile users
INIT_SEAFILE_MYSQL_ROOT_PASSWORD=password

## Seafile admin user
INIT_SEAFILE_ADMIN_EMAIL=
INIT_SEAFILE_ADMIN_PASSWORD=

## SeaSearch admin user
## (valid in enabling SeaSearch and use Seafile admin by default)
INIT_SS_ADMIN_USER=$INIT_SEAFILE_ADMIN_EMAIL
INIT_SS_ADMIN_PASSWORD=$INIT_SEAFILE_ADMIN_PASSWORD

############################################
# Additional configurations for extensions #
############################################

## SeaDoc service
ENABLE_SEADOC=true

## SeaSearch

### Local cache
SS_MAX_OBJ_CACHE_SIZE=10GB

### Log
SS_LOG_TO_STDOUT=false
SS_LOG_OUTPUT=true
SS_LOG_LEVEL=info

## Notification
ENABLE_NOTIFICATION_SERVER=false
NOTIFICATION_SERVER_URL=

## Seafile AI
ENABLE_SEAFILE_AI=false
SEAFILE_AI_LLM_TYPE=openai
SEAFILE_AI_LLM_URL=
SEAFILE_AI_LLM_KEY= # your llm key
SEAFILE_AI_LLM_MODEL=gpt-4o-mini

## Metadata server
MD_FILE_COUNT_LIMIT=100000Code-Sprache: PHP (php)

Nun erstellen wir uns ein Konfigurationsskript, welches die env anpasst:

cd /opt/containers/seafile-pro
nano first_setup.sh

Inhalt:

#!/bin/bash
set -e

ENV_FILE=".env"

# --- 1. Prüfen, ob .env existiert ---
if [ ! -f "$ENV_FILE" ]; then
    echo "Fehler: $ENV_FILE nicht gefunden!"
    exit 1
fi

echo "--- Seafile Konfiguration ---"

# --- 2. Interaktive Abfragen ---
# Standardwerte auslesen (falls vorhanden), sonst Defaults setzen
current_host=$(grep "^SEAFILE_SERVER_HOSTNAME=" "$ENV_FILE" | cut -d= -f2 | tr -d '"' || echo "seafile.deinedomain.de")
read -p "Seafile Domain eingeben [$current_host]: " input_host
SEAFILE_HOST="${input_host:-$current_host}"

current_email=$(grep "^INIT_SEAFILE_ADMIN_EMAIL=" "$ENV_FILE" | cut -d= -f2 | tr -d '"' || echo "admin@example.com")
read -p "Admin E-Mail eingeben [$current_email]: " input_email
ADMIN_EMAIL="${input_email:-$current_email}"

# Admin Passwort Abfrage
read -s -p "Admin Passwort für Web-Login eingeben (leer lassen für Generierung): " input_admin_pw
echo ""
if [ -z "$input_admin_pw" ]; then
    ADMIN_PW=$(openssl rand -base64 12 | tr -dc 'a-zA-Z0-9')
    echo "-> Generiertes Admin Passwort: $ADMIN_PW"
else
    ADMIN_PW="$input_admin_pw"
fi

current_tz=$(grep "^TIME_ZONE=" "$ENV_FILE" | cut -d= -f2 | tr -d '"' || echo "Europe/Berlin")
read -p "Zeitzone eingeben [$current_tz]: " input_tz
TIME_ZONE="${input_tz:-$current_tz}"


# --- 3. Automatische Generierung von Secrets ---
# Funktion für sichere Strings (nur Alphanumerisch um Probleme in URLs/DBs zu vermeiden)
generate_secret() {
    openssl rand -base64 24 | tr -dc 'a-zA-Z0-9' | head -c 24
}

DB_PASSWORD=$(generate_secret)
ROOT_DB_PASSWORD=$(generate_secret)
JWT_KEY=$(generate_secret) # JWT Key (als String)

echo "-> Generiere Datenbank-Passwörter und JWT Key..."


# --- 4. Backup erstellen ---
cp "$ENV_FILE" "$ENV_FILE.bak.$(date +%Y%m%d_%H%M%S)"
echo "-> Backup erstellt als $ENV_FILE.bak..."


# --- 5. Werte ersetzen (Sed Funktion für Mac/Linux Kompatibilität) ---
update_env() {
    local key=$1
    local val=$2
    # Escape Special Characters für sed (z.B. & /)
    # Wir nutzen | als Trenner, da in URLs oft / vorkommt
    if grep -q "^$key=" "$ENV_FILE"; then
        # Wert existiert: Ersetzen
        # Mac OS sed braucht '' nach -i, Linux nicht. Wir nutzen eine temporäre Datei.
        sed "s|^$key=.*|$key=$val|" "$ENV_FILE" > "$ENV_FILE.tmp" && mv "$ENV_FILE.tmp" "$ENV_FILE"
    else
        # Wert existiert nicht: Anhängen
        echo "$key=$val" >> "$ENV_FILE"
    fi
}

# Werte schreiben
update_env "SEAFILE_SERVER_HOSTNAME" "$SEAFILE_HOST"
update_env "TIME_ZONE" "$TIME_ZONE"
update_env "JWT_PRIVATE_KEY" "$JWT_KEY"

# Admin User
update_env "INIT_SEAFILE_ADMIN_EMAIL" "$ADMIN_EMAIL"
update_env "INIT_SEAFILE_ADMIN_PASSWORD" "$ADMIN_PW"

# DB Passwörter
update_env "SEAFILE_MYSQL_DB_PASSWORD" "$DB_PASSWORD"
update_env "INIT_SEAFILE_MYSQL_ROOT_PASSWORD" "$ROOT_DB_PASSWORD"

# URL/Protokoll sicherstellen
update_env "SEAFILE_SERVER_PROTOCOL" "https"

echo ""
echo "✅ Konfiguration abgeschlossen!"
echo "------------------------------------------------"
echo "Admin Login: $ADMIN_EMAIL"
echo "Admin Pass:  $ADMIN_PW"
echo "Domain:      https://$SEAFILE_HOST"
echo "------------------------------------------------"
Code-Sprache: PHP (php)

Dieses Skript machen wir nun noch ausführbar und starten es:

chmod +x first_setup.sh
./first_setup.sh

5. Server starten

Den Server startet ihr wie gewohnt mit folgendem Befehl:

docker compose -f /opt/containers/seafile-pro/docker-compose.yml up -d

Wartet nun ca 1 Minute. Nun sollte es so aussehen, wenn ihr auf “seafile.euredomain.de” geht.

6. Collabora Office Integration

Nun habt ihr noch die Möglichkeit Collabora Office in Seafile zu Integrieren. Bei Collabora Office handelt es sich um eine kostenloses Online Office, welches ihr selbst hosten könnt. Alle Infos dazu findet ihr hier.